package com.hongyi.websocket.utils;

import com.hongyi.common.framework.utils.common.CollectionUtils;
import com.hongyi.common.redis.utils.RedisUtils;
import com.hongyi.websocket.domain.WebSocketMessageDto;
import com.hongyi.websocket.holder.WebSocketSessionHolder;
import lombok.AccessLevel;
import lombok.NoArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.socket.PongMessage;
import org.springframework.web.socket.TextMessage;
import org.springframework.web.socket.WebSocketMessage;
import org.springframework.web.socket.WebSocketSession;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;

import static com.hongyi.common.framework.constant.WebSocketConstants.WEB_SOCKET_TOPIC;


/**
 * 工具类
 *
 * @author DingHao
 */
@Slf4j
@NoArgsConstructor(access = AccessLevel.PRIVATE)
public class WebSocketUtils {

    /**
     * 发送消息
     *
     * <p>根据用户ID (sessionKey) 发送文本消息</p>
     * @param sessionKey session主键 一般为用户id
     * @param message    消息文本
     */
    public static void sendMessage(Long sessionKey, String message) {
        //通过WebSocketSessionHolder获取对应的WebSocketSession对象
        WebSocketSession session = WebSocketSessionHolder.getSessions(sessionKey);
        //调用另一个sendMessage方法来实际发送消息
        sendMessage(session, message);
    }

    /**
     * 订阅消息
     *
     * <p>订阅一个Redis主题消息</p>
     * @param consumer 自定义处理
     */
    public static void subscribeMessage(Consumer<WebSocketMessageDto> consumer) {
        //订阅一个Redis主题（WEB_SOCKET_TOPIC），当有新消息到达时，触发给定的consumer函数进行处理
        RedisUtils.subscribe(WEB_SOCKET_TOPIC, WebSocketMessageDto.class, consumer);
    }

    /**
     * 发布订阅的消息
     *
     * <p>将消息发布到Redis主题，以便其他订阅者可以接收到</p>
     * @param webSocketMessage 消息对象
     */
    public static void publishMessage(WebSocketMessageDto webSocketMessage) {
        List<Long> unsentSessionKeys = new ArrayList<>();
        // 当前服务内session,直接发送消息
        for (Long sessionKey : webSocketMessage.getSessionKeys()) {
            if (WebSocketSessionHolder.existSession(sessionKey)) {
                WebSocketUtils.sendMessage(sessionKey, webSocketMessage.getMessage());
                continue;
            }
            unsentSessionKeys.add(sessionKey);
        }
        // 不在当前服务内session,发布订阅消息
        if (CollectionUtils.isNotEmpty(unsentSessionKeys)) {
            WebSocketMessageDto broadcastMessage = new WebSocketMessageDto();
            broadcastMessage.setMessage(webSocketMessage.getMessage());
            broadcastMessage.setSessionKeys(unsentSessionKeys);
            RedisUtils.publish(WEB_SOCKET_TOPIC, broadcastMessage, consumer -> {
                log.info(" WebSocket发送主题订阅消息topic:{} session keys:{} message:{}",
                    WEB_SOCKET_TOPIC, unsentSessionKeys, webSocketMessage.getMessage());
            });
        }
    }

    /**
     * 发布订阅的消息(群发)
     *
     * <p>向所有订阅者广播一条消息</p>
     * @param message 消息内容
     */
    public static void publishAll(String message) {
        WebSocketMessageDto broadcastMessage = new WebSocketMessageDto();
        broadcastMessage.setMessage(message);
        //发布到Redis主题。这将使所有订阅了该主题的服务实例都能接收到这条消息
        RedisUtils.publish(WEB_SOCKET_TOPIC, broadcastMessage, consumer -> {
            log.info("WebSocket发送主题订阅消息topic:{} message:{}", WEB_SOCKET_TOPIC, message);
        });
    }

    /**
     * 发送Pong消息
     *
     * <p>发送一个Pong消息，用于保持WebSocket连接的活跃性</p>
     * @param session WebSocketSession对象
     */
    public static void sendPongMessage(WebSocketSession session) {
        sendMessage(session, new PongMessage());
    }

    /**
     * 发送文本消息
     *
     * <p>发送一个文本消息</p>
     * @param session WebSocketSession对象
     * @param message 消息内容
     */
    public static void sendMessage(WebSocketSession session, String message) {
        sendMessage(session, new TextMessage(message));
    }

    /**
     * 发送消息
     *
     * <p>实际发送WebSocket消息的核心方法</p>
     * @param session WebSocketSession对象
     * @param message 消息对象
     */
    private static void sendMessage(WebSocketSession session, WebSocketMessage<?> message) {
        if (session == null || !session.isOpen()) {//检查session是否为空或已关闭，如果是，则记录警告日志
            log.warn("[send] session会话已经关闭");
        } else {
            try {//如果session有效且处于打开状态，尝试发送消息
                session.sendMessage(message);
            } catch (IOException e) {//如果发送过程中发生异常，记录错误日志
                log.error("[send] session({}) 发送消息({}) 异常", session, message, e);
            }
        }
    }
}
